package edu.vital.energy.longevity.ch10.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;

import java.time.Duration;
import java.util.HashMap;
import java.util.Map;

@Configuration   // 定义一个配置类
public class RedisConfig   {
    @Autowired
    private RedisConnectionFactory factory;

//    @Bean
//    public CacheManager cacheManager() {
//        // 1. 设置默认缓存配置
//
//    }
//    /**
//     * 重写Redis序列化方式，使用Json方式:
//     * 当我们的数据存储到Redis的时候，我们的键（key）和值（value）都是通过Spring提供的Serializer序列化到数据库的。RedisTemplate默认使用的是JdkSerializationRedisSerializer，StringRedisTemplate默认使用的是StringRedisSerializer。
//     * Spring Data JPA为我们提供了下面的Serializer：
//     * GenericToStringSerializer、Jackson2JsonRedisSerializer、JacksonJsonRedisSerializer、JdkSerializationRedisSerializer、OxmSerializer、StringRedisSerializer。
//     * 在此我们将自己配置RedisTemplate并定义Serializer。
//     *
//     * @param redisConnectionFactory
//     * @return
//     */
//    @Bean
//    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
//        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
//        redisTemplate.setConnectionFactory(redisConnectionFactory);
//
////        JdkSerializationRedisSerializer jdkSerializationRedisSerializer = new JdkSerializationRedisSerializer();
//        GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
//
//        // 设置值（value）的序列化采用FastJsonRedisSerializer。
//        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
////        redisTemplate.setHashValueSerializer(fastJsonRedisSerializer);
//        // 设置键（key）的序列化采用StringRedisSerializer。
//        redisTemplate.setKeySerializer(new StringRedisSerializer());
//        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
//        redisTemplate.afterPropertiesSet();
//        return redisTemplate;
//    }
//
//    //缓存管理器
//    @Bean
//    public CacheManager cacheManager(RedisConnectionFactory lettuceConnectionFactory) {
//        RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig();
//        // 设置缓存管理器管理的缓存的默认过期时间
//        defaultCacheConfig = defaultCacheConfig.entryTtl(Duration.ofMinutes(60))
//                // 不缓存空值
//                .disableCachingNullValues();
//
//        Set<String> cacheNames = new HashSet<>();
//        cacheNames.add("my-redis-cache1");
//
//        // 对每个缓存空间应用不同的配置
//        Map<String, RedisCacheConfiguration> configMap = new HashMap<>();
//        configMap.put("my-redis-cache1", defaultCacheConfig.entryTtl(Duration.ofMinutes(50)));
//
//        RedisCacheManager cacheManager = RedisCacheManager.builder(lettuceConnectionFactory)
//                .cacheDefaults(defaultCacheConfig)
//                .initialCacheNames(cacheNames)
//                .withInitialCacheConfigurations(configMap)
//                .build();
//        return cacheManager;
//    }

//@Bean
//public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
//
//    // 创建默认的 RedisCacheConfiguration，并设置全局缓存过期时间
//    RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig()
//            .entryTtl(Duration.ofMinutes(5))  // 默认全局缓存过期时间为5分钟
//            .disableCachingNullValues();      // 禁止缓存 null 值
//
//    // 为特定缓存配置不同的过期策略
//    Map<String, RedisCacheConfiguration> cacheConfigurations = new HashMap<>();
//
//    // 配置名为 "shortLivedCache" 的缓存，设置过期时间为1分钟
//    cacheConfigurations.put("shortLivedCache",
//            RedisCacheConfiguration.defaultCacheConfig()
//                    .entryTtl(Duration.ofMinutes(1)) // 设置缓存的TTL为1分钟
//                    .disableCachingNullValues());    // 禁止缓存 null 值
//
//    // 配置名为 "longLivedCache" 的缓存，设置过期时间为1小时
//    cacheConfigurations.put("longLivedCache",
//            RedisCacheConfiguration.defaultCacheConfig()
//                    .entryTtl(Duration.ofHours(1))  // 设置缓存的TTL为1小时
//                    .disableCachingNullValues());    // 禁止缓存 null 值
//
//    // 配置名为 "jsonCache" 的缓存，使用 JSON 序列化器
//    cacheConfigurations.put("jsonCache",
//            RedisCacheConfiguration.defaultCacheConfig()
//                    .entryTtl(Duration.ofMinutes(30))  // 30分钟过期
//                    .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
//                    .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()))
//                    .disableCachingNullValues());       // 禁止缓存 null 值
//
//    // 创建 RedisCacheManager，加载自定义的缓存配置
//    return RedisCacheManager.builder(redisConnectionFactory)
//            .cacheDefaults(defaultCacheConfig)   // 设置默认的缓存配置
//            .withInitialCacheConfigurations(cacheConfigurations) // 加载不同缓存区域的配置
//            .build();
//}
}

